#pragma once

#include <queue>
#include <mutex>
#include <condition_variable>
#include <stdexcept>

template <typename T>
class ThreadSafeQueue
{
public:
    ThreadSafeQueue() = default;
    ~ThreadSafeQueue() = default;

    // 禁用拷贝和赋值操作
    ThreadSafeQueue(const ThreadSafeQueue&) = delete;
    ThreadSafeQueue& operator=(const ThreadSafeQueue&) = delete;

    // 入队操作
    void push(const T& value) {
        std::lock_guard<std::mutex> lock(_mutex);
        _queue.push(value);
        _condition.notify_one(); // 通知等待的线程有新元素入队
    }

    void push(T&& value) {
        std::lock_guard<std::mutex> lock(_mutex);
        _queue.push(std::move(value));
        _condition.notify_one(); // 通知等待的线程有新元素入队
    }

    // 安全的出队操作，只进行移出操作
    void pop() {
        std::lock_guard<std::mutex> lock(_mutex);
        if (!_queue.empty()) {
            _queue.pop();
        }
    }

    // 非阻塞获取队列前端元素
    T front() const {
        std::lock_guard<std::mutex> lock(_mutex);
        if (_queue.empty()) {
            throw std::out_of_range("Queue is empty");
        }
        return _queue.front();
    }

    // 阻塞获取队列前端元素
    T wait_and_front() {
        std::unique_lock<std::mutex> lock(_mutex);
        _condition.wait(lock, [this]() { return !_queue.empty(); });
        return _queue.front();
    }

    // 检查队列是否为空
    bool empty() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _queue.empty();
    }

    // 获取队列的大小
    std::size_t size() const {
        std::lock_guard<std::mutex> lock(_mutex);
        return _queue.size();
    }

private:
    std::queue<T> _queue;             // 实际存储数据的队列
    mutable std::mutex _mutex;        // 用于保护队列的互斥锁
    std::condition_variable _condition; // 用于同步的条件变量
};
